using Fiddler;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Diagnostics;
using System.Drawing;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using TangCaptureTraffic.Services;

namespace TangCaptureTraffic
{
    /// <summary>
    /// 会话信息面板用户控件，用于显示网络会话的详细信息，包括请求/响应数据、JSON和图片预览
    /// </summary>
    public partial class SessionInfoPanel : UserControl
    {
        private readonly ISessionFormattingService _sessionFormattingService;
        private Form _form;

        public SessionInfoPanel(Form form)
        {
            _form = form;
            InitializeComponent();
            // 初始时隐藏控制面板，只有在显示JSON时才会显示
            pnlJsonControl.Visible = false;

            // 从ServiceContainer获取服务实例
            _sessionFormattingService = ServiceContainer.Instance.GetService<ISessionFormattingService>();
        }

        private Session _session;
        /// <summary>
        /// 获取或设置当前显示的会话对象
        /// 设置会话时会自动触发UI初始化显示会话内容
        /// </summary>
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public Session Session
        {
            set
            {
                try
                {
                    if (value != null)
                    {
                        if (_session != null && _session.id == value.id) return;
                        _session = value;
                        Initialization();
                    }
                }
                catch (Exception ex)
                {
                    // 在UI线程上显示错误信息
                    this.Invoke((MethodInvoker)delegate
                    {
                        txtRequest.Text = "加载请求信息时出错";
                        txtResponse.Text = $"加载响应信息时出错: {ex.Message}";
                    });

                    Debug.WriteLine($"加载会话内容时出错: {ex.Message}");
                }
            }
        }

        /// <summary>
        /// 展开全部按钮点击事件处理方法
        /// 展开JSON树中的所有节点
        /// </summary>
        /// <param name="sender">事件发送者</param>
        /// <param name="e">事件参数</param>
        private void btnExpandAll_Click(object sender, EventArgs e)
        {
            try
            {
                Debug.WriteLine("展开所有JSON节点");
                //var items = JsonTree.Items;
                //foreach (var item in items)
                //{
                //    if (item!=null&&(bool)item.CanExpand)
                //    {
                //        item.Expand = true;
                //    }
                //}
                JsonTree.ExpandAll();
            }
            catch (Exception ex)
            {
                Debug.WriteLine($"展开JSON节点时出错: {ex.Message}");
            }
        }

        /// <summary>
        /// 关闭全部按钮点击事件处理方法
        /// 折叠JSON树中的所有节点
        /// </summary>
        /// <param name="sender">事件发送者</param>
        /// <param name="e">事件参数</param>
        private void btnCollapseAll_Click(object sender, EventArgs e)
        {
            try
            {
                Debug.WriteLine("折叠所有JSON节点");

                JsonTree.ExpandAll(false);
            }
            catch (Exception ex)
            {
                Debug.WriteLine($"折叠JSON节点时出错: {ex.Message}");
            }
        }

        /// <summary>
        /// 初始化会话信息显示，根据内容类型自动选择合适的展示方式
        /// 支持文本、JSON和图片类型的响应内容展示
        /// </summary>
        private void Initialization()
        {
            try
            {
                // 先清除当前显示的内容
                this.Invoke((MethodInvoker)delegate
                {
                    // 显示加载提示
                    txtRequest.Text = "正在加载请求信息...";
                    txtResponse.Text = "正在加载响应信息...";

                    // 隐藏JSON树和图片
                    JsonTree.Visible = false;
                    pnlJsonControl.Visible = false;
                    imgResponse.Visible = false;

                    // 默认显示文本响应
                    tabResponse.SelectedIndex = 0;
                });

                // 检查会话大小，决定加载策略
                bool isLargeSession = (_session.RequestBody?.Length > 500000) || (_session.ResponseBody?.Length > 1000000);

                // 对于大型会话，显示更详细的加载提示
                if (isLargeSession)
                {
                    this.Invoke((MethodInvoker)delegate
                    {
                        txtRequest.Text = "正在加载大型请求信息...请求大小: " +
                            (_session.RequestBody != null ? (_session.RequestBody.Length / 1024) + " KB" : "未知");

                        txtResponse.Text = "正在加载大型响应信息...响应大小: " +
                            (_session.ResponseBody != null ? (_session.ResponseBody.Length / 1024) + " KB" : "未知");
                    });
                }

                // 使用异步方法加载内容
                Task.Run(() => LoadSessionContentAsync());
            }
            catch (Exception ex)
            {
                Debug.WriteLine($"初始化会话信息时出错: {ex.Message}");
                this.Invoke((MethodInvoker)delegate
                {
                    txtRequest.Text = "加载请求信息时出错: " + ex.Message;
                    txtResponse.Text = "加载响应信息时出错: " + ex.Message;
                });
            }
        }

        /// <summary>
        /// 异步加载会话内容
        /// </summary>
        private async Task LoadSessionContentAsync()
        {
            if (_session == null) return;

            try
            {
                // 检查会话大小，决定加载策略
                bool isLargeSession = (_session.RequestBody?.Length > 500000) || (_session.ResponseBody?.Length > 1000000);
                bool isVeryLargeSession = (_session.RequestBody?.Length > 2000000) || (_session.ResponseBody?.Length > 5000000);

                // 使用服务格式化请求和响应文本
                string requestText = null;
                string responseText = null;

                // 先加载请求文本，这样用户可以先看到请求信息
                await Task.Run(() =>
                {
                    try
                    {
                        // 对于非常大的请求，使用较大的maxLength参数
                        int maxLength = isVeryLargeSession ? 2000 : 5000;
                        requestText = _sessionFormattingService.FormatRequestText(_session);
                    }
                    catch (Exception ex)
                    {
                        requestText = $"加载请求信息时出错: {ex.Message}";
                        Debug.WriteLine($"加载请求文本时出错: {ex.Message}");
                    }
                });

                // 立即更新请求文本
                this.Invoke((MethodInvoker)delegate
                {
                    txtRequest.Text = requestText;
                });

                // 再加载响应文本
                await Task.Run(() =>
                {
                    try
                    {
                        // 对于非常大的响应，使用较大的maxLength参数
                        int maxLength = isVeryLargeSession ? 2000 : 5000;
                        responseText = _sessionFormattingService.FormatResponseText(_session);
                    }
                    catch (Exception ex)
                    {
                        responseText = $"加载响应信息时出错: {ex.Message}";
                        Debug.WriteLine($"加载响应文本时出错: {ex.Message}");
                    }
                });

                // 使用Invoke确保在UI线程上更新控件
                this.Invoke((MethodInvoker)delegate
                {
                    // 设置响应文本
                    txtResponse.Text = responseText;

                    // 隐藏JSON树和图片
                    JsonTree.Visible = false;
                    pnlJsonControl.Visible = false; // 隐藏JSON控制面板
                    imgResponse.Visible = false;

                    // 默认显示文本响应
                    tabResponse.SelectedIndex = 0;
                });

                // 检查Content-Type是否为JSON
                var contentType = _session.ResponseHeaders["Content-Type"]?.ToLower();

                // 如果是大型会话且是JSON类型，则延迟加载JSON预览
                if (!string.IsNullOrEmpty(contentType) && contentType.Contains("application/json"))
                {
                    // 对于大型JSON，先显示加载提示
                    if (isLargeSession)
                    {
                        this.Invoke((MethodInvoker)delegate
                        {
                            JsonTree.Visible = true;
                            // pnlJsonControl.Visible = true;
                            //                          JsonTree.SetJson("{\
                            //\"message\": \"正在加载大型JSON数据，请稍候...\",\
                            //\"size\": \"" + (_session.ResponseBody?.Length / 1024) + " KB\",\
                            //\"status\": \"loading\"\}");
                        });
                    }

                    // 异步加载JSON数据
                    await ProcessJsonResponseAsync();
                }
                // 检查是否为图片类型
                else if (!string.IsNullOrEmpty(contentType) &&
                        (contentType.Contains("image/") ||
                         contentType.Contains("image-")))
                {
                    // 异步加载图片数据
                    await ProcessImageResponseAsync();
                }
            }
            catch (Exception ex)
            {
                Debug.WriteLine($"加载会话内容时出错: {ex.Message}");

                // 在UI线程上显示错误信息
                this.Invoke((MethodInvoker)delegate
                {
                    txtResponse.Text += $"\n\n[加载会话内容时出错: {ex.Message}]";
                });
            }
        }

        /// <summary>
        /// 异步处理JSON响应
        /// </summary>
        private async Task ProcessJsonResponseAsync()
        {
            try
            {
                // 检查响应体大小
                bool isLargeJson = _session.ResponseBody != null && _session.ResponseBody.Length > 1000000; // 1MB
                bool isVeryLargeJson = _session.ResponseBody != null && _session.ResponseBody.Length > 5000000; // 5MB

                // 在UI线程上显示加载提示（如果尚未显示）
                this.Invoke((MethodInvoker)delegate
                {
                    if (!JsonTree.Visible)
                    {
                        JsonTree.Visible = true;
                        // pnlJsonControl.Visible = true;

                        if (isVeryLargeJson)
                        {
                            // 对于超大型JSON，显示更详细的加载提示
                            double sizeMB = Math.Round(_session.ResponseBody.Length / (1024.0 * 1024.0), 2);
                            JsonTree.SetJson("{\"message\": \"正在加载超大型JSON数据，这可能需要一些时间...\",\"size\": \"" + sizeMB + " MB\",\"status\": \"loading\",\"note\": \"处理大型数据时，请耐心等待\"}");
                        }
                        else if (isLargeJson)
                        {
                            JsonTree.SetJson("{\"message\": \"正在加载JSON数据，请稍候...\",\"size\": \"" + (_session.ResponseBody?.Length / 1024) + " KB\",\"status\": \"loading\"}");
                        }
                    }
                });

                // 获取响应体并解析为JSON
                string jsonText = null;

                // 使用异步方法获取响应体
                await Task.Run(() =>
                {
                    try
                    {
                        jsonText = _session.GetResponseBodyAsString();
                    }
                    catch (Exception ex)
                    {
                        Debug.WriteLine($"获取JSON响应体时出错: {ex.Message}");
                        return;
                    }
                });

                if (string.IsNullOrEmpty(jsonText))
                {
                    // 在UI线程上显示错误信息
                    this.Invoke((MethodInvoker)delegate
                    {
                        JsonTree.SetJson("{\"error\": \"JSON数据为空\",\"message\": \"响应体不包含有效的JSON数据\",\"suggestion\": \"请检查请求是否成功，或者响应是否为其他格式\"}");

                        // 显示状态栏提示
                        if (ParentForm != null)
                        {
                            try
                            {
                                var mainForm = ParentForm;
                                var method = mainForm.GetType().GetMethod("ShowStatusMessage", System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic);
                                if (method != null)
                                {
                                    method.Invoke(mainForm, new object[] { "警告: JSON数据为空", 2000 });
                                }
                            }
                            catch
                            {
                                // 忽略状态栏显示错误
                            }
                        }
                    });
                    return;
                }

                // 检查JSON是否有效
                bool isValidJson = false;
                try
                {
                    // 简单验证JSON格式
                    if (jsonText.Trim().StartsWith("{") && jsonText.Trim().EndsWith("}") ||
                        jsonText.Trim().StartsWith("[") && jsonText.Trim().EndsWith("]"))
                    {
                        isValidJson = true;
                    }
                }
                catch
                {
                    // 忽略验证错误
                }

                if (!isValidJson)
                {
                    // 在UI线程上显示错误信息
                    this.Invoke((MethodInvoker)delegate
                    {
                        JsonTree.SetJson("{\"error\": \"无效的JSON格式\",\"message\": \"响应体不是有效的JSON格式\",\"suggestion\": \"请检查响应内容是否为其他格式，如HTML或纯文本\"}");
                        Debug.WriteLine("无效的JSON格式: " + (jsonText.Length > 100 ? jsonText.Substring(0, 100) + "..." : jsonText));
                    });
                    return;
                }

                // 使用Invoke确保在UI线程上更新控件
                this.Invoke((MethodInvoker)delegate
                {
                    try
                    {
                        // 使用JsonTree控件显示JSON数据
                        JsonTree.Dock = DockStyle.Fill;
                        JsonTree.Visible = true;
                        // pnlJsonControl.Visible = true; // 显示JSON控制面板

                        // 对于大型JSON，分批处理以避免UI冻结
                        if (isVeryLargeJson)
                        {
                            // 先显示超大型JSON的加载提示
                            double sizeMB = Math.Round(jsonText.Length / (1024.0 * 1024.0), 2);
                            JsonTree.SetJson("{\"message\": \"正在解析超大型JSON数据，这可能需要一些时间...\",\"size\": \"" + sizeMB + " MB\",\"status\": \"parsing\",\"note\": \"正在优化内存使用，请耐心等待\"}");
                        }
                        else if (isLargeJson && jsonText.Length > 500000) // 500KB
                        {
                            // 先显示加载提示
                            JsonTree.SetJson("{\"message\": \"正在加载JSON数据，请稍候...\",\"size\": \"" + (_session.ResponseBody?.Length / 1024) + " KB\",\"status\": \"loading\"}");


                            // 使用低优先级任务异步设置JSON
                            Task.Factory.StartNew(() =>
                            {
                                try
                                {
                                    // 对于超大型JSON，使用更高效的内存管理
                                    if (isVeryLargeJson)
                                    {
                                        // 在设置JSON前进行一次GC，释放内存
                                        GC.Collect(2, GCCollectionMode.Optimized);
                                    }

                                    // 在新线程中解析JSON
                                    this.Invoke((MethodInvoker)delegate
                                    {
                                        try
                                        {
                                            // 设置JSON前显示处理状态
                                            if (isVeryLargeJson)
                                            {
                                                double sizeMB = Math.Round(jsonText.Length / (1024.0 * 1024.0), 2);
                                                JsonTree.SetJson("{\"message\": \"正在渲染超大型JSON数据...\",\"size\": \"" + sizeMB + " MB\",\"status\": \"rendering\",\"progress\": \"90%\"}");

                                                // 给UI线程一点时间更新
                                                Application.DoEvents();
                                            }

                                            // 设置JSON并切换标签页
                                            JsonTree.SetJson(jsonText);
                                            tabResponse.SelectedIndex = 1;

                                            // 对于超大型JSON，完成后提示用户
                                            if (isVeryLargeJson)
                                            {
                                                Debug.WriteLine($"成功加载超大型JSON数据: {jsonText.Length / (1024.0 * 1024.0):F2} MB");
                                            }
                                        }
                                        catch (Exception ex)
                                        {
                                            // 如果解析JSON失败，显示详细错误信息
                                            string sizeInfo = isVeryLargeJson ?
                                                $"{jsonText.Length / (1024.0 * 1024.0):F2} MB" :
                                                $"{jsonText.Length / 1024} KB";

                                            JsonTree.SetJson("{\"error\": \"JSON解析错误\",\"message\": \"" + ex.Message + "\",\"size\": \"" + sizeInfo + "\",\"suggestion\": \"JSON数据可能格式不正确或过大，请检查数据格式\"}");
                                            Debug.WriteLine($"解析{(isVeryLargeJson ? "超大型" : "大型")}JSON时出错: {ex.Message}");
                                        }
                                    });
                                }
                                catch (Exception ex)
                                {
                                    Debug.WriteLine($"异步设置{(isVeryLargeJson ? "超大型" : "大型")}JSON时出错: {ex.Message}");

                                    // 在UI线程上显示错误信息
                                    this.Invoke((MethodInvoker)delegate
                                    {
                                        JsonTree.SetJson("{\"error\": \"JSON处理错误\",\"message\": \"" + ex.Message + "\",\"suggestion\": \"请尝试刷新或重新加载会话\"}");
                                    });
                                }
                            }, TaskCreationOptions.LongRunning);
                        }
                        else
                        {
                            // 对于小型JSON，也提供基本的处理状态反馈
                            try
                            {
                                // 显示简单的加载提示
                                if (jsonText.Length > 100000) // 100KB以上的JSON也显示加载提示
                                {
                                    JsonTree.SetJson("{\"message\": \"正在处理JSON数据...\",\"size\": \"" + (jsonText.Length / 1024) + " KB\",\"status\": \"processing\"}");

                                    // 给UI线程一点时间更新
                                    Application.DoEvents();
                                }

                                // 设置JSON并切换标签页
                                JsonTree.SetJson(jsonText);
                                tabResponse.SelectedIndex = 1;
                            }
                            catch (Exception ex)
                            {
                                // 处理小型JSON解析错误
                                Debug.WriteLine($"解析小型JSON时出错: {ex.Message}");
                                JsonTree.SetJson("{\"error\": \"JSON解析错误\",\"message\": \"" + ex.Message + "\",\"size\": \"" + (jsonText.Length / 1024) + " KB\"}");
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        // 如果解析JSON失败，回退到文本显示
                        tabResponse.SelectedIndex = 0;
                        pnlJsonControl.Visible = false; // 隐藏JSON控制面板
                        Debug.WriteLine($"JSON解析错误: {ex.Message}");
                        txtResponse.Text += $"\n\n[JSON解析错误: {ex.Message}]";
                    }
                });
            }
            catch (Exception ex)
            {
                Debug.WriteLine($"处理JSON响应时出错: {ex.Message}");
                Debug.WriteLine($"异常堆栈: {ex.StackTrace}");

                // 在UI线程上显示错误信息
                this.Invoke((MethodInvoker)delegate
                {
                    tabResponse.SelectedIndex = 0; // 切换到文本标签页
                    txtResponse.Text += $"\n\n[JSON处理错误: {ex.Message}]";

                    // 如果JSON树已显示，也在JSON树中显示错误
                    if (JsonTree.Visible)
                    {
                        JsonTree.SetJson("{\"error\": \"JSON处理错误\",\"message\": \"" + ex.Message + "\",\"type\": \"" + ex.GetType().Name + "\",\"suggestion\": \"请尝试刷新或重新加载会话，如果问题持续存在，请检查网络连接\"}");
                    }

                    // 显示状态栏提示
                    if (ParentForm != null)
                    {
                        try
                        {
                            var mainForm = ParentForm;
                            var method = mainForm.GetType().GetMethod("ShowStatusMessage", System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic);
                            if (method != null)
                            {
                                method.Invoke(mainForm, new object[] { $"JSON处理错误: {ex.Message}", 3000 });
                            }
                        }
                        catch
                        {
                            // 忽略状态栏显示错误
                        }
                    }
                });
            }
        }

        /// <summary>
        /// 异步处理图片响应
        /// </summary>
        private async Task ProcessImageResponseAsync()
        {
            try
            {
                // 检查图片大小
                bool isLargeImage = _session.ResponseBody != null && _session.ResponseBody.Length > 5000000; // 5MB

                // 在UI线程上显示加载提示
                if (isLargeImage)
                {
                    this.Invoke((MethodInvoker)delegate
                    {
                        // 切换到图片标签页并显示加载提示
                        tabResponse.SelectedIndex = 2;
                        imgResponse.Visible = true;
                        imgResponse.Image = null;
                        txtResponse.Text += $"\n\n[正在加载大型图片，大小: {_session.ResponseBody.Length / 1024} KB]";
                    });
                }

                // 获取响应体并转换为图片
                byte[] imageData = null;

                // 使用异步方法获取图片数据
                await Task.Run(() =>
                {
                    try
                    {
                        imageData = _session.GetResponseBodyAsBytes();
                    }
                    catch (Exception ex)
                    {
                        Debug.WriteLine($"获取图片数据时出错: {ex.Message}");
                        return;
                    }
                });

                if (imageData == null || imageData.Length == 0) return;

                // 使用异步方法创建图片对象
                Image image = null;
                await Task.Run(() =>
                {
                    try
                    {
                        using (var ms = new MemoryStream(imageData))
                        {
                            // 对于大型图片，考虑创建缩略图以减少内存使用
                            if (isLargeImage)
                            {
                                // 先加载原始图片
                                var originalImage = Image.FromStream(ms);

                                // 计算合适的缩略图大小，保持原始比例
                                int maxDimension = 1024; // 最大尺寸为1024像素
                                int width = originalImage.Width;
                                int height = originalImage.Height;

                                if (width > height && width > maxDimension)
                                {
                                    height = (int)(height * ((float)maxDimension / width));
                                    width = maxDimension;
                                }
                                else if (height > width && height > maxDimension)
                                {
                                    width = (int)(width * ((float)maxDimension / height));
                                    height = maxDimension;
                                }

                                // 创建缩略图
                                image = new Bitmap(width, height);
                                using (Graphics g = Graphics.FromImage(image))
                                {
                                    g.InterpolationMode = System.Drawing.Drawing2D.InterpolationMode.HighQualityBicubic;
                                    g.DrawImage(originalImage, 0, 0, width, height);
                                }

                                // 释放原始图片资源
                                originalImage.Dispose();
                            }
                            else
                            {
                                // 对于小型图片，直接加载
                                image = Image.FromStream(ms);
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        Debug.WriteLine($"创建图片对象时出错: {ex.Message}");
                    }
                });

                // 使用Invoke确保在UI线程上更新控件
                this.Invoke((MethodInvoker)delegate
                {
                    try
                    {
                        if (image != null)
                        {
                            // 使用imgResponse控件显示图片
                            imgResponse.Image = image;
                            imgResponse.Width = image.Width;
                            imgResponse.Height = image.Height;
                            imgResponse.Visible = true;

                            // 自动切换到图片标签页
                            tabResponse.SelectedIndex = 2;

                            // 如果是大型图片，添加提示信息
                            if (isLargeImage)
                            {
                                txtResponse.Text += $"\n\n[已加载图片缩略图，原始大小: {_session.ResponseBody.Length / 1024} KB]";
                            }
                        }
                        else
                        {
                            // 如果图片为空，回退到文本显示
                            tabResponse.SelectedIndex = 0;
                            txtResponse.Text += $"\n\n[无法加载图片]";
                        }
                    }
                    catch (Exception ex)
                    {
                        // 如果显示图片失败，回退到文本显示
                        tabResponse.SelectedIndex = 0;
                        txtResponse.Text += $"\n\n[图片显示错误: {ex.Message}]";
                        Debug.WriteLine($"图片显示错误: {ex.Message}");

                        // 释放图片资源
                        image?.Dispose();
                    }
                });
            }
            catch (Exception ex)
            {
                Debug.WriteLine($"处理图片响应时出错: {ex.Message}");

                // 在UI线程上显示错误信息
                this.Invoke((MethodInvoker)delegate
                {
                    tabResponse.SelectedIndex = 0; // 切换到文本标签页
                    txtResponse.Text += $"\n\n[图片处理错误: {ex.Message}]";
                });
            }
        }

        /// <summary>
        /// 清除会话信息显示，重置面板状态并释放资源
        /// </summary>
        public void Clear()
        {
            try
            {
                // 取消所有正在进行的异步任务
                // 注意：这里我们不能直接取消Task，但可以通过设置会话为null来避免后续处理
                _session = null;

                // 使用Invoke确保在UI线程上清理资源
                this.Invoke((MethodInvoker)delegate
                {
                    try
                    {
                        // 清除请求和响应文本
                        txtRequest.Clear();
                        txtResponse.Clear();

                        // 隐藏并清除JSON树
                        JsonTree.Visible = false;
                        pnlJsonControl.Visible = false; // 隐藏JSON控制面板
                        JsonTree.Items.Clear();

                        // 隐藏并清除图片
                        imgResponse.Visible = false;
                        if (imgResponse.Image != null)
                        {
                            imgResponse.Image.Dispose();
                            imgResponse.Image = null;
                        }

                        // 重置标签页到默认状态
                        tabResponse.SelectedIndex = 0;
                    }
                    catch (Exception ex)
                    {
                        Debug.WriteLine($"在UI线程清除会话信息时出错: {ex.Message}");
                    }
                });

                // 使用低优先级任务进行内存清理，避免阻塞UI
                Task.Factory.StartNew(() =>
                {
                    try
                    {
                        // 强制垃圾回收以释放内存
                        GC.Collect(2, GCCollectionMode.Optimized, false);
                        GC.WaitForPendingFinalizers();

                        // 对大型对象堆进行压缩
                        GC.Collect(2, GCCollectionMode.Optimized, true);
                    }
                    catch (Exception ex)
                    {
                        Debug.WriteLine($"执行内存清理时出错: {ex.Message}");
                    }
                }, TaskCreationOptions.LongRunning);
            }
            catch (Exception ex)
            {
                Debug.WriteLine($"清除会话信息时出错: {ex.Message}");
            }
        }

        private void imgResponse_Click(object sender, EventArgs e)
        {
            AntdUI.Preview.open(new AntdUI.Preview.Config(_form, this.imgResponse.Image));
        }
    }
}
